home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / Memory.p < prev    next >
Encoding:
Text File  |  1996-09-22  |  15.6 KB  |  602 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Memory.p
  3.  
  4.      Contains:    Memory Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1.4
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Memory;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __MEMORY__}
  30. {$SETC __MEMORY__ := 1}
  31.  
  32. {$I+}
  33. {$SETC MemoryIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __MIXEDMODE__}
  43. {$I MixedMode.p}
  44. {$ENDC}
  45.  
  46. {$PUSH}
  47. {$ALIGN MAC68K}
  48. {$LibExport+}
  49.  
  50. CONST
  51.     maxSize                        = $800000;                        {Max data block size is 8 megabytes}
  52.     defaultPhysicalEntryCount    = 8;
  53. { values returned from the GetPageState function }
  54.     kPageInMemory                = 0;
  55.     kPageOnDisk                    = 1;
  56.     kNotPaged                    = 2;
  57.  
  58. { masks for Zone->heapType field }
  59.     k32BitHeap                    = 1;                            { valid in all Memory Managers }
  60.     kNewStyleHeap                = 2;                            { true if new Heap Manager is present }
  61.     kNewDebugHeap                = 4;                            { true if new Heap Manager is running in debug mode on this heap }
  62.  
  63. { size of a block in bytes }
  64.     
  65. TYPE
  66.     Size = LONGINT;
  67.  
  68.     GrowZoneProcPtr = ProcPtr;  { FUNCTION GrowZone(cbNeeded: Size): LONGINT; }
  69.     PurgeProcPtr = ProcPtr;  { PROCEDURE Purge(blockToPurge: Handle); }
  70.     {
  71.         UserFnProcPtr uses register based parameters on the 68k and cannot
  72.         be written in or called from a high-level language without the help of
  73.         mixed mode or assembly glue.
  74.  
  75.         In:
  76.          => *parameter      A0.L
  77.     }
  78.     UserFnProcPtr = Register68kProcPtr;  { register PROCEDURE UserFn(parameter: UNIV Ptr); }
  79.     GrowZoneUPP = UniversalProcPtr;
  80.     PurgeUPP = UniversalProcPtr;
  81.     UserFnUPP = UniversalProcPtr;
  82.  
  83.     THz = ^Zone;
  84.  
  85.     Zone = RECORD
  86.         bkLim:                    Ptr;
  87.         purgePtr:                Ptr;
  88.         hFstFree:                Ptr;
  89.         zcbFree:                LONGINT;
  90.         gzProc:                    GrowZoneUPP;
  91.         moreMast:                INTEGER;
  92.         flags:                    INTEGER;
  93.         cntRel:                    INTEGER;
  94.         maxRel:                    INTEGER;
  95.         cntNRel:                INTEGER;
  96.         heapType:                SInt8; (* Byte *)
  97.         unused:                    SInt8; (* Byte *)
  98.         cntEmpty:                INTEGER;
  99.         cntHandles:                INTEGER;
  100.         minCBFree:                LONGINT;
  101.         purgeProc:                PurgeUPP;
  102.         sparePtr:                Ptr;
  103.         allocPtr:                Ptr;
  104.         heapData:                INTEGER;
  105.     END;
  106.  
  107.     MemoryBlock = RECORD
  108.         address:                Ptr;
  109.         count:                    LONGINT;
  110.     END;
  111.  
  112.     LogicalToPhysicalTable = RECORD
  113.         logical:                MemoryBlock;
  114.         physical:                ARRAY [0..defaultPhysicalEntryCount-1] OF MemoryBlock;
  115.     END;
  116.  
  117.     PageState = INTEGER;
  118.  
  119.     StatusRegisterContents = INTEGER;
  120.  
  121. CONST
  122.     uppGrowZoneProcInfo = $000000F0; { FUNCTION (4 byte param): 4 byte result; }
  123.     uppPurgeProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  124.     uppUserFnProcInfo = $00009802; { Register PROCEDURE (4 bytes in A0); }
  125.  
  126. FUNCTION NewGrowZoneProc(userRoutine: GrowZoneProcPtr): GrowZoneUPP;
  127.     {$IFC NOT GENERATINGCFM }
  128.     INLINE $2E9F;
  129.     {$ENDC}
  130.  
  131. FUNCTION NewPurgeProc(userRoutine: PurgeProcPtr): PurgeUPP;
  132.     {$IFC NOT GENERATINGCFM }
  133.     INLINE $2E9F;
  134.     {$ENDC}
  135.  
  136. FUNCTION NewUserFnProc(userRoutine: UserFnProcPtr): UserFnUPP;
  137.     {$IFC NOT GENERATINGCFM }
  138.     INLINE $2E9F;
  139.     {$ENDC}
  140.  
  141. FUNCTION CallGrowZoneProc(cbNeeded: Size; userRoutine: GrowZoneUPP): LONGINT;
  142.     {$IFC NOT GENERATINGCFM}
  143.     INLINE $205F, $4E90;
  144.     {$ENDC}
  145.  
  146. PROCEDURE CallPurgeProc(blockToPurge: Handle; userRoutine: PurgeUPP);
  147.     {$IFC NOT GENERATINGCFM}
  148.     INLINE $205F, $4E90;
  149.     {$ENDC}
  150.  
  151. PROCEDURE CallUserFnProc(parameter: UNIV Ptr; userRoutine: UserFnUPP);
  152.     {$IFC NOT GENERATINGCFM}
  153.     {To be implemented:  Glue to move parameters into registers.}
  154.     {$ENDC}
  155. FUNCTION GetApplLimit : Ptr;
  156.     {$IFC NOT CFMSYSTEMCALLS}
  157.     INLINE $2EB8, $0130;            { MOVE.l $0130,(SP) }
  158.     {$ENDC}
  159.  
  160. FUNCTION SystemZone : THz;
  161.     {$IFC NOT CFMSYSTEMCALLS}
  162.     INLINE $2EB8, $02A6;            { MOVE.l $02A6,(SP) }
  163.     {$ENDC}
  164.  
  165. FUNCTION ApplicationZone : THz;
  166.     {$IFC NOT CFMSYSTEMCALLS}
  167.     INLINE $2EB8, $02AA;            { MOVE.l $02AA,(SP) }
  168.     {$ENDC}
  169.  
  170. FUNCTION GZSaveHnd : Handle;
  171.     {$IFC NOT CFMSYSTEMCALLS}
  172.     INLINE $2EB8, $0328;            { MOVE.l $0328,(SP) }
  173.     {$ENDC}
  174.  
  175. FUNCTION TopMem : Ptr;
  176.     {$IFC NOT CFMSYSTEMCALLS}
  177.     INLINE $2EB8, $0108;            { MOVE.l $0108,(SP) }
  178.     {$ENDC}
  179.  
  180. FUNCTION MemError : OSErr;
  181.     {$IFC NOT CFMSYSTEMCALLS}
  182.     INLINE $3EB8, $0220;            { MOVE.w $0220,(SP) }
  183.     {$ENDC}
  184.  
  185. FUNCTION GetZone: THz;
  186.     {$IFC NOT GENERATINGCFM}
  187.     INLINE $A11A, $2E88;
  188.     {$ENDC}
  189. FUNCTION NewHandle(byteCount: Size): Handle;
  190.     {$IFC NOT GENERATINGCFM}
  191.     INLINE $201F, $A122, $2E88;
  192.     {$ENDC}
  193. FUNCTION NewHandleSys(byteCount: Size): Handle;
  194.     {$IFC NOT GENERATINGCFM}
  195.     INLINE $201F, $A522, $2E88;
  196.     {$ENDC}
  197. FUNCTION NewHandleClear(byteCount: Size): Handle;
  198.     {$IFC NOT GENERATINGCFM}
  199.     INLINE $201F, $A322, $2E88;
  200.     {$ENDC}
  201. FUNCTION NewHandleSysClear(byteCount: Size): Handle;
  202.     {$IFC NOT GENERATINGCFM}
  203.     INLINE $201F, $A722, $2E88;
  204.     {$ENDC}
  205. FUNCTION HandleZone(h: Handle): THz;
  206.     {$IFC NOT GENERATINGCFM}
  207.     INLINE $205F, $A126, $2E88;
  208.     {$ENDC}
  209. FUNCTION RecoverHandle(p: Ptr): Handle;
  210.     {$IFC NOT GENERATINGCFM}
  211.     INLINE $205F, $A128, $2E88;
  212.     {$ENDC}
  213. FUNCTION RecoverHandleSys(p: Ptr): Handle;
  214.     {$IFC NOT GENERATINGCFM}
  215.     INLINE $205F, $A528, $2E88;
  216.     {$ENDC}
  217. FUNCTION NewPtr(byteCount: Size): Ptr;
  218.     {$IFC NOT GENERATINGCFM}
  219.     INLINE $201F, $A11E, $2E88;
  220.     {$ENDC}
  221. FUNCTION NewPtrSys(byteCount: Size): Ptr;
  222.     {$IFC NOT GENERATINGCFM}
  223.     INLINE $201F, $A51E, $2E88;
  224.     {$ENDC}
  225. FUNCTION NewPtrClear(byteCount: Size): Ptr;
  226.     {$IFC NOT GENERATINGCFM}
  227.     INLINE $201F, $A31E, $2E88;
  228.     {$ENDC}
  229. FUNCTION NewPtrSysClear(byteCount: Size): Ptr;
  230.     {$IFC NOT GENERATINGCFM}
  231.     INLINE $201F, $A71E, $2E88;
  232.     {$ENDC}
  233. FUNCTION PtrZone(p: Ptr): THz;
  234.     {$IFC NOT GENERATINGCFM}
  235.     INLINE $205F, $A148, $2E88;
  236.     {$ENDC}
  237. FUNCTION MaxBlock: LONGINT;
  238.     {$IFC NOT GENERATINGCFM}
  239.     INLINE $A061, $2E80;
  240.     {$ENDC}
  241. FUNCTION MaxBlockSys: LONGINT;
  242.     {$IFC NOT GENERATINGCFM}
  243.     INLINE $A461, $2E80;
  244.     {$ENDC}
  245. FUNCTION StackSpace: LONGINT;
  246.     {$IFC NOT GENERATINGCFM}
  247.     INLINE $A065, $2E80;
  248.     {$ENDC}
  249. FUNCTION NewEmptyHandle: Handle;
  250.     {$IFC NOT GENERATINGCFM}
  251.     INLINE $A166, $2E88;
  252.     {$ENDC}
  253. FUNCTION NewEmptyHandleSys: Handle;
  254.     {$IFC NOT GENERATINGCFM}
  255.     INLINE $A566, $2E88;
  256.     {$ENDC}
  257. PROCEDURE HLock(h: Handle);
  258.     {$IFC NOT GENERATINGCFM}
  259.     INLINE $205F, $A029;
  260.     {$ENDC}
  261. PROCEDURE HUnlock(h: Handle);
  262.     {$IFC NOT GENERATINGCFM}
  263.     INLINE $205F, $A02A;
  264.     {$ENDC}
  265. PROCEDURE HPurge(h: Handle);
  266.     {$IFC NOT GENERATINGCFM}
  267.     INLINE $205F, $A049;
  268.     {$ENDC}
  269. PROCEDURE HNoPurge(h: Handle);
  270.     {$IFC NOT GENERATINGCFM}
  271.     INLINE $205F, $A04A;
  272.     {$ENDC}
  273. PROCEDURE HLockHi(h: Handle);
  274.     {$IFC NOT GENERATINGCFM}
  275.     INLINE $205F, $A064, $A029;
  276.     {$ENDC}
  277. FUNCTION TempNewHandle(logicalSize: Size; VAR resultCode: OSErr): Handle;
  278.     {$IFC NOT GENERATINGCFM}
  279.     INLINE $3F3C, $001D, $A88F;
  280.     {$ENDC}
  281. FUNCTION TempMaxMem(VAR grow: Size): Size;
  282.     {$IFC NOT GENERATINGCFM}
  283.     INLINE $3F3C, $0015, $A88F;
  284.     {$ENDC}
  285. FUNCTION TempFreeMem: LONGINT;
  286.     {$IFC NOT GENERATINGCFM}
  287.     INLINE $3F3C, $0018, $A88F;
  288.     {$ENDC}
  289. {  Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  }
  290. PROCEDURE TempHLock(h: Handle; VAR resultCode: OSErr);
  291.     {$IFC NOT GENERATINGCFM}
  292.     INLINE $3F3C, $001E, $A88F;
  293.     {$ENDC}
  294. PROCEDURE TempHUnlock(h: Handle; VAR resultCode: OSErr);
  295.     {$IFC NOT GENERATINGCFM}
  296.     INLINE $3F3C, $001F, $A88F;
  297.     {$ENDC}
  298. PROCEDURE TempDisposeHandle(h: Handle; VAR resultCode: OSErr);
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $3F3C, $0020, $A88F;
  301.     {$ENDC}
  302. FUNCTION TempTopMem: Ptr;
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $3F3C, $0016, $A88F;
  305.     {$ENDC}
  306. PROCEDURE InitApplZone;
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $A02C;
  309.     {$ENDC}
  310. PROCEDURE InitZone(pgrowZone: GrowZoneUPP; cmoreMasters: INTEGER; limitPtr: UNIV Ptr; startPtr: UNIV Ptr);
  311. PROCEDURE SetZone(hz: THz);
  312.     {$IFC NOT GENERATINGCFM}
  313.     INLINE $205F, $A01B;
  314.     {$ENDC}
  315. FUNCTION CompactMem(cbNeeded: Size): Size;
  316.     {$IFC NOT GENERATINGCFM}
  317.     INLINE $201F, $A04C, $2E80;
  318.     {$ENDC}
  319. FUNCTION CompactMemSys(cbNeeded: Size): Size;
  320.     {$IFC NOT GENERATINGCFM}
  321.     INLINE $201F, $A44C, $2E80;
  322.     {$ENDC}
  323. PROCEDURE PurgeMem(cbNeeded: Size);
  324.     {$IFC NOT GENERATINGCFM}
  325.     INLINE $201F, $A04D;
  326.     {$ENDC}
  327. PROCEDURE PurgeMemSys(cbNeeded: Size);
  328.     {$IFC NOT GENERATINGCFM}
  329.     INLINE $201F, $A44D;
  330.     {$ENDC}
  331. FUNCTION FreeMem: LONGINT;
  332.     {$IFC NOT GENERATINGCFM}
  333.     INLINE $A01C, $2E80;
  334.     {$ENDC}
  335. FUNCTION FreeMemSys: LONGINT;
  336.     {$IFC NOT GENERATINGCFM}
  337.     INLINE $A41C, $2E80;
  338.     {$ENDC}
  339. PROCEDURE ReserveMem(cbNeeded: Size);
  340.     {$IFC NOT GENERATINGCFM}
  341.     INLINE $201F, $A040;
  342.     {$ENDC}
  343. PROCEDURE ReserveMemSys(cbNeeded: Size);
  344.     {$IFC NOT GENERATINGCFM}
  345.     INLINE $201F, $A440;
  346.     {$ENDC}
  347. FUNCTION MaxMem(VAR grow: Size): Size;
  348.     {$IFC NOT GENERATINGCFM}
  349.     INLINE $225F, $A11D, $2288, $2E80;
  350.     {$ENDC}
  351. FUNCTION MaxMemSys(VAR grow: Size): Size;
  352.     {$IFC NOT GENERATINGCFM}
  353.     INLINE $225F, $A51D, $2288, $2E80;
  354.     {$ENDC}
  355. PROCEDURE SetGrowZone(growZone: GrowZoneUPP);
  356.     {$IFC NOT GENERATINGCFM}
  357.     INLINE $205F, $A04B;
  358.     {$ENDC}
  359. PROCEDURE SetApplLimit(zoneLimit: UNIV Ptr);
  360.     {$IFC NOT GENERATINGCFM}
  361.     INLINE $205F, $A02D;
  362.     {$ENDC}
  363. PROCEDURE MoveHHi(h: Handle);
  364.     {$IFC NOT GENERATINGCFM}
  365.     INLINE $205F, $A064;
  366.     {$ENDC}
  367. PROCEDURE DisposePtr(p: Ptr);
  368.     {$IFC NOT GENERATINGCFM}
  369.     INLINE $205F, $A01F;
  370.     {$ENDC}
  371. FUNCTION GetPtrSize(p: Ptr): Size;
  372. PROCEDURE SetPtrSize(p: Ptr; newSize: Size);
  373.     {$IFC NOT GENERATINGCFM}
  374.     INLINE $201F, $205F, $A020;
  375.     {$ENDC}
  376. PROCEDURE DisposeHandle(h: Handle);
  377.     {$IFC NOT GENERATINGCFM}
  378.     INLINE $205F, $A023;
  379.     {$ENDC}
  380. PROCEDURE SetHandleSize(h: Handle; newSize: Size);
  381.     {$IFC NOT GENERATINGCFM}
  382.     INLINE $201F, $205F, $A024;
  383.     {$ENDC}
  384. FUNCTION GetHandleSize(h: Handle): Size;
  385. FUNCTION InlineGetHandleSize(h: Handle): Size;
  386.     {$IFC NOT GENERATINGCFM}
  387.     INLINE $205F, $A025, $2E80;
  388.     {$ENDC}
  389. PROCEDURE ReallocateHandle(h: Handle; byteCount: Size);
  390.     {$IFC NOT GENERATINGCFM}
  391.     INLINE $201F, $205F, $A027;
  392.     {$ENDC}
  393. PROCEDURE EmptyHandle(h: Handle);
  394.     {$IFC NOT GENERATINGCFM}
  395.     INLINE $205F, $A02B;
  396.     {$ENDC}
  397. PROCEDURE HSetRBit(h: Handle);
  398.     {$IFC NOT GENERATINGCFM}
  399.     INLINE $205F, $A067;
  400.     {$ENDC}
  401. PROCEDURE HClrRBit(h: Handle);
  402.     {$IFC NOT GENERATINGCFM}
  403.     INLINE $205F, $A068;
  404.     {$ENDC}
  405. PROCEDURE MoreMasters;
  406.     {$IFC NOT GENERATINGCFM}
  407.     INLINE $A036;
  408.     {$ENDC}
  409. PROCEDURE BlockMove(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size);
  410.     {$IFC NOT GENERATINGCFM}
  411.     INLINE $201F, $225F, $205F, $A02E;
  412.     {$ENDC}
  413. PROCEDURE BlockMoveData(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size);
  414.     {$IFC NOT GENERATINGCFM}
  415.     INLINE $201F, $225F, $205F, $A22E;
  416.     {$ENDC}
  417. {
  418.     These four routines are intended to be used by developers writing drivers.
  419.     They do not exist in “InterfaceLib.” You must link with “DriverServicesLib” to access them.
  420.     
  421.         BlockMoveUncached
  422.         BlockMoveDataUncached
  423.         BlockZero
  424.         BlockZeroUncached
  425.     
  426.     Note: BlockMove and BlockMoveData exist in both in “InterfaceLib” and “DriverServicesLib.” 
  427.     You cannot link with both libraries.
  428.     
  429. }
  430. PROCEDURE BlockMoveUncached(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size); C;
  431. PROCEDURE BlockMoveDataUncached(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size); C;
  432. PROCEDURE BlockZero(destPtr: UNIV Ptr; byteCount: Size); C;
  433. PROCEDURE BlockZeroUncached(destPtr: UNIV Ptr; byteCount: Size); C;
  434.  
  435. PROCEDURE PurgeSpace(VAR total: LONGINT; VAR contig: LONGINT);
  436. FUNCTION HGetState(h: Handle): SInt8;
  437.     {$IFC NOT GENERATINGCFM}
  438.     INLINE $205F, $A069, $1E80;
  439.     {$ENDC}
  440. PROCEDURE HSetState(h: Handle; flags: ByteParameter);
  441.     {$IFC NOT GENERATINGCFM}
  442.     INLINE $101F, $205F, $A06A;
  443.     {$ENDC}
  444. PROCEDURE SetApplBase(startPtr: UNIV Ptr);
  445.     {$IFC NOT GENERATINGCFM}
  446.     INLINE $205F, $A057;
  447.     {$ENDC}
  448. PROCEDURE MaxApplZone;
  449.     {$IFC NOT GENERATINGCFM}
  450.     INLINE $A063;
  451.     {$ENDC}
  452. FUNCTION HoldMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  453.     {$IFC NOT GENERATINGCFM}
  454.     INLINE $225F, $205F, $7000, $A05C, $3E80;
  455.     {$ENDC}
  456. FUNCTION UnholdMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  457.     {$IFC NOT GENERATINGCFM}
  458.     INLINE $225F, $205F, $7001, $A05C, $3E80;
  459.     {$ENDC}
  460. FUNCTION LockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  461.     {$IFC NOT GENERATINGCFM}
  462.     INLINE $225F, $205F, $7002, $A05C, $3E80;
  463.     {$ENDC}
  464. FUNCTION LockMemoryContiguous(address: UNIV Ptr; count: LONGINT): OSErr;
  465.     {$IFC NOT GENERATINGCFM}
  466.     INLINE $225F, $205F, $7004, $A05C, $3E80;
  467.     {$ENDC}
  468. FUNCTION UnlockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  469.     {$IFC NOT GENERATINGCFM}
  470.     INLINE $225F, $205F, $7003, $A05C, $3E80;
  471.     {$ENDC}
  472. FUNCTION GetPhysical(VAR addresses: LogicalToPhysicalTable; VAR physicalEntryCount: LONGINT): OSErr;
  473. FUNCTION DeferUserFn(userFunction: UserFnUPP; argument: UNIV Ptr): OSErr;
  474.     {$IFC NOT GENERATINGCFM}
  475.     INLINE $201F, $205F, $A08F, $3E80;
  476.     {$ENDC}
  477. FUNCTION DebuggerGetMax: LONGINT;
  478.     {$IFC NOT GENERATINGCFM}
  479.     INLINE $7000, $A08D, $2E80;
  480.     {$ENDC}
  481. PROCEDURE DebuggerEnter;
  482.     {$IFC NOT GENERATINGCFM}
  483.     INLINE $7001, $A08D;
  484.     {$ENDC}
  485. PROCEDURE DebuggerExit;
  486.     {$IFC NOT GENERATINGCFM}
  487.     INLINE $7002, $A08D;
  488.     {$ENDC}
  489. PROCEDURE DebuggerPoll;
  490.     {$IFC NOT GENERATINGCFM}
  491.     INLINE $7003, $A08D;
  492.     {$ENDC}
  493. FUNCTION GetPageState(address: UNIV Ptr): PageState;
  494.     {$IFC NOT GENERATINGCFM}
  495.     INLINE $205F, $7004, $A08D, $3E80;
  496.     {$ENDC}
  497. FUNCTION PageFaultFatal: BOOLEAN;
  498.     {$IFC NOT GENERATINGCFM}
  499.     INLINE $7005, $A08D, $1E80;
  500.     {$ENDC}
  501. FUNCTION DebuggerLockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  502.     {$IFC NOT GENERATINGCFM}
  503.     INLINE $225F, $205F, $7006, $A08D, $3E80;
  504.     {$ENDC}
  505. FUNCTION DebuggerUnlockMemory(address: UNIV Ptr; count: LONGINT): OSErr;
  506.     {$IFC NOT GENERATINGCFM}
  507.     INLINE $225F, $205F, $7007, $A08D, $3E80;
  508.     {$ENDC}
  509. FUNCTION EnterSupervisorMode: StatusRegisterContents;
  510.     {$IFC NOT GENERATINGCFM}
  511.     INLINE $7008, $A08D, $3E80;
  512.     {$ENDC}
  513. { StripAddress and Translate24To32 macro to nothing on PowerPC
  514.    StripAddress is implemented as a trap in System 6 or later }
  515. {$IFC SystemSixOrLater }
  516. FUNCTION StripAddress(theAddress: UNIV Ptr): Ptr;
  517.     {$IFC NOT GENERATINGCFM}
  518.     INLINE $201F, $A055, $2E80;
  519.     {$ENDC}
  520. {$ELSEC}
  521. FUNCTION StripAddress(theAddress: UNIV Ptr): Ptr;
  522. {$ENDC}
  523. FUNCTION Translate24To32(addr24: UNIV Ptr): Ptr;
  524.     {$IFC NOT GENERATINGCFM}
  525.     INLINE $201F, $A091, $2E80;
  526.     {$ENDC}
  527. FUNCTION HandToHand(VAR theHndl: Handle): OSErr;
  528. FUNCTION PtrToXHand(srcPtr: UNIV Ptr; dstHndl: Handle; size: LONGINT): OSErr;
  529.     {$IFC NOT GENERATINGCFM}
  530.     INLINE $201F, $225F, $205F, $A9E2, $3E80;
  531.     {$ENDC}
  532. FUNCTION PtrToHand(srcPtr: UNIV Ptr; VAR dstHndl: Handle; size: LONGINT): OSErr;
  533. FUNCTION HandAndHand(hand1: Handle; hand2: Handle): OSErr;
  534.     {$IFC NOT GENERATINGCFM}
  535.     INLINE $225F, $205F, $A9E4, $3E80;
  536.     {$ENDC}
  537. FUNCTION PtrAndHand(ptr1: UNIV Ptr; hand2: Handle; size: LONGINT): OSErr;
  538.     {$IFC NOT GENERATINGCFM}
  539.     INLINE $201F, $225F, $205F, $A9EF, $3E80;
  540.     {$ENDC}
  541. {$IFC OLDROUTINENAMES }
  542. FUNCTION ApplicZone: THz;
  543.     {$IFC NOT GENERATINGCFM}
  544.     INLINE $2EB8, $02AA;
  545.     {$ENDC}
  546. FUNCTION MFTempNewHandle(logicalSize: Size; VAR resultCode: OSErr): Handle;
  547.     {$IFC NOT GENERATINGCFM}
  548.     INLINE $3F3C, $001D, $A88F;
  549.     {$ENDC}
  550. FUNCTION MFMaxMem(VAR grow: Size): Size;
  551.     {$IFC NOT GENERATINGCFM}
  552.     INLINE $3F3C, $0015, $A88F;
  553.     {$ENDC}
  554. FUNCTION MFFreeMem: LONGINT;
  555.     {$IFC NOT GENERATINGCFM}
  556.     INLINE $3F3C, $0018, $A88F;
  557.     {$ENDC}
  558. PROCEDURE MFTempHLock(h: Handle; VAR resultCode: OSErr);
  559.     {$IFC NOT GENERATINGCFM}
  560.     INLINE $3F3C, $001E, $A88F;
  561.     {$ENDC}
  562. PROCEDURE MFTempHUnlock(h: Handle; VAR resultCode: OSErr);
  563.     {$IFC NOT GENERATINGCFM}
  564.     INLINE $3F3C, $001F, $A88F;
  565.     {$ENDC}
  566. PROCEDURE MFTempDisposHandle(h: Handle; VAR resultCode: OSErr);
  567.     {$IFC NOT GENERATINGCFM}
  568.     INLINE $3F3C, $0020, $A88F;
  569.     {$ENDC}
  570. FUNCTION MFTopMem: Ptr;
  571.     {$IFC NOT GENERATINGCFM}
  572.     INLINE $3F3C, $0016, $A88F;
  573.     {$ENDC}
  574. PROCEDURE ResrvMem(cbNeeded: Size);
  575.     {$IFC NOT GENERATINGCFM}
  576.     INLINE $201F, $A040;
  577.     {$ENDC}
  578. PROCEDURE DisposPtr(p: Ptr);
  579.     {$IFC NOT GENERATINGCFM}
  580.     INLINE $205F, $A01F;
  581.     {$ENDC}
  582. PROCEDURE DisposHandle(h: Handle);
  583.     {$IFC NOT GENERATINGCFM}
  584.     INLINE $205F, $A023;
  585.     {$ENDC}
  586. PROCEDURE ReallocHandle(h: Handle; byteCount: Size);
  587.     {$IFC NOT GENERATINGCFM}
  588.     INLINE $201F, $205F, $A027;
  589.     {$ENDC}
  590. {$ENDC}
  591.  
  592. {$ALIGN RESET}
  593. {$POP}
  594.  
  595. {$SETC UsingIncludes := MemoryIncludes}
  596.  
  597. {$ENDC} {__MEMORY__}
  598.  
  599. {$IFC NOT UsingIncludes}
  600.  END.
  601. {$ENDC}
  602.